package com.neuedu.dao;

import com.neuedu.common.DBUtil;

import java.sql.*;
import java.util.*;

public class BaseDao {
    public List<Map<String,Object>> querySql(Connection con,String sql){
        PreparedStatement ps;
        ResultSet rs;
        Map<String,Object> map;
        List<Map<String,Object>> list=new ArrayList<>();
        try {
            ps=con.prepareStatement(sql);
            rs=ps.executeQuery();
            ResultSetMetaData data = rs.getMetaData();
            while (rs.next()){
                map=new HashMap<>();
                for (int i=1;i<=data.getColumnCount();i++){
                    String nameCol=data.getColumnLabel(i);
                    String name=rs.getString(nameCol);
                    map.put(nameCol,name);
                }
                list.add(map);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return list;
    }



        public List<Map<String,Object>> querySql1(Connection con,String sql,Object[] objs){
            PreparedStatement ps;
            ResultSet rs;
            Map<String,Object> map;
            List<Map<String,Object>> list=new ArrayList<>();
            try {
                ps=con.prepareStatement(sql);
                ResultSetMetaData metaData = ps.getMetaData();
                int col=metaData.getColumnCount();
                if (col!=objs.length){
                    throw new SQLException("参数数量不匹配");
                }
                for (int i = 0; i < objs.length; i++) {
                    ps.setString(i,objs[i].toString());
                }
                rs=ps.executeQuery();
                ResultSetMetaData data = rs.getMetaData();
                while (rs.next()){
                    map=new HashMap<>();
                    for (int i=1;i<=data.getColumnCount();i++){
                        String nameCol=data.getColumnLabel(i);
                        String name=rs.getString(nameCol);
                        map.put(nameCol,name);
                    }
                    list.add(map);
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            return list;
        }

    /**
     * 带参数的无别名sql查询
     *
     * @param sql  要执行的sql语句
     * @param parm sql语句中的参数
     * @param con  数据库连接
     * @return
     * @throws SQLException
     */
//    public List<Map<String,Object>> queryParmSqlAsName(String sql,Object[] parm,Connection con) throws SQLException{
//        //预编译sql语句
//        PreparedStatement pred = con.prepareStatement(sql);
//        //取得预编译sql的元数据
//        ParameterMetaData pmd = pred.getParameterMetaData();
//        //得到预编译sql的参数数量（在sql中问号的数量）
//        int a = pmd.getParameterCount();
//        //如果元数据中预编译sql的参数数量，和parm形参参数数量，不一致，抛出异常
//        if(a != parm.length) {
//            throw new SQLException("参数数量不匹配");
//        }
//        //循环给预编译的问号赋值（暂时不考虑数据类型情况）
//        for(int i=0; i<parm.length; i++) {
//            pred.setString(i+1, parm[i].toString());
//        }
//        //执行sql语句，得到结果集
//        ResultSet rest = pred.executeQuery();
//        //得到结果集的元数据
//        ResultSetMetaData md = rest.getMetaData();
//        //变量：保存所有查询结果
//        List<Map<String,Object>> list = new ArrayList<>();
//        //遍历结果集
//        while(rest.next()) {
//            //结果集，一行的数据，保存到一个map对象中
//            Map<String, Object> map = new HashMap<>();
//            //循环当前行的列，将每列的数据，放置到map中，map的长度与列数一致
//            for (int i = 0; i < md.getColumnCount(); i++) {
//                //cn:数据库列名字（别名），存放到map的key
//                String cn = md.getColumnName(i + 1);
//                //rn:数据库中值，存放到map的value
//                String rn = rest.getString(cn);
//                //map中保存该行所有列的数据
//                map.put(cn, rn);
//            }
//            list.add(map);
//        }
//        return list;
//    }
    public List<Map<String, Object>> queryParmSqlAsName(String sql, Object[] parm, Connection con) throws SQLException {
        //预编译sql语句
        PreparedStatement pred = con.prepareStatement(sql);
        //取得预编译sql的元数据
        ParameterMetaData pmd = pred.getParameterMetaData();
        //得到预编译sql的参数数量（在sql中问号的数量）
        int a = pmd.getParameterCount();
        //如果元数据中预编译sql的参数数量，和parm形参参数数量，不一致，抛出异常
        if (a != parm.length) {
            throw new SQLException("参数数量不匹配");
        }
        //循环给预编译的问号赋值（暂时不考虑数据类型情况）
        for(int i = 0; i<parm.length; i++) {
            if (parm[i] instanceof String) {
                pred.setString(i + 1, parm[i].toString());
            }
            if (parm[i] instanceof Integer) {
                pred.setInt(i + 1, (int) parm[i]);
            }
        }
        //执行sql语句，得到结果集
        ResultSet rest = pred.executeQuery();
        //得到结果集的元数据
        ResultSetMetaData md = rest.getMetaData();
        //变量：保存所有查询结果
        List<Map<String,Object>> list = new ArrayList<>();
        //遍历结果集
        while(rest.next()) {
            //结果集，一行的数据，保存到一个map对象中
            Map<String, Object> map = new HashMap<>();
            //循环当前行的列，将每列的数据，放置到map中，map的长度与列数一致
            for (int i = 0; i < md.getColumnCount(); i++) {
                //cn:数据库列名字（别名），存放到map的key
                String cn = md.getColumnName(i + 1);
                //rn:数据库中值，存放到map的value
                String rn = rest.getString(cn);
                //map中保存该行所有列的数据
                map.put(cn, rn);
            }
            list.add(map);
        }
        return list;
    }

    public List<Map<String, Object>> queryParmSqlAsName(String sql, int[] parm, Connection con) throws SQLException {
        //预编译sql语句
        PreparedStatement pred = con.prepareStatement(sql);
        //取得预编译sql的元数据
        ParameterMetaData pmd = pred.getParameterMetaData();
        //得到预编译sql的参数数量（在sql中问号的数量）
        int a = pmd.getParameterCount();
        //如果元数据中预编译sql的参数数量，和parm形参参数数量，不一致，抛出异常
        if (a != parm.length) {
            throw new SQLException("参数数量不匹配");
        }
        //循环给预编译的问号赋值（暂时不考虑数据类型情况）
        for (int i = 0; i < parm.length; i++) {
            pred.setInt(i + 1, parm[i]);
        }
        //执行sql语句，得到结果集
        ResultSet rest = pred.executeQuery();
        //得到结果集的元数据
        ResultSetMetaData md = rest.getMetaData();
        //变量：保存所有查询结果
        List<Map<String, Object>> list = new ArrayList<>();
        //遍历结果集
        while (rest.next()) {
            //结果集，一行的数据，保存到一个map对象中
            Map<String, Object> map = new HashMap<>();
            //循环当前行的列，将每列的数据，放置到map中，map的长度与列数一致
            for (int i = 0; i < md.getColumnCount(); i++) {
                //cn:数据库列名字（别名），存放到map的key
                String cn = md.getColumnName(i + 1);
                //rn:数据库中值，存放到map的value
                String rn = rest.getString(cn);
                //map中保存该行所有列的数据
                map.put(cn, rn);
            }
            list.add(map);
        }
        return list;
    }

    public int delUpins(String sql, Object[] parm, Connection con) throws SQLException {
        //预编译sql语句
        PreparedStatement pred = con.prepareStatement(sql);
        //取得预编译sql的元数据
        ParameterMetaData pmd = pred.getParameterMetaData();
        //得到预编译sql的参数数量（在sql中问号的数量）
        int a = pmd.getParameterCount();
        int flag=-1;
        //如果元数据中预编译sql的参数数量，和parm形参参数数量，不一致，抛出异常
        if(a != parm.length) {
            throw new SQLException("参数数量不匹配");
        }

        //循环给预编译的问号赋值（暂时不考虑数据类型情况）
        for(int i=0;i<parm.length;i++) {
            pred.setString(i+1, parm[i].toString());
        }
        //执行sql语句，得到结果集
        flag= pred.executeUpdate();
        return flag;
    }


}
